/*
 * NGramas64.cpp
 *
 *  Created on: 18/11/2014
 *      Author: juan manuel
 */

#include "NGramas64.h"
#define CUALQUIER_PALABRA "zxcvb"
#define FACTOR_TRIGRAMA 0.7
#define FACTOR_BIGRAMA 0.25
#define NOMBRE_ARCHIVO_TRIGRAMAS "trigramas.txt"


map<string,sFreqArchivo> diccionario;

map<string, datosDeUnaPAlabraDelDiccionario> diccionarioCompleto;

map<int, sPalabraYFrecuencia> diccionarioPorIndice;



void agregarTrigrama(string palabra1, string palabra2, string palabra3){
	agregarPalabraAlDiccionario(palabra1);
	agregarPalabraAlDiccionario(palabra2);
	agregarPalabraAlDiccionario(palabra3);

	diccionarioCompleto[palabra1].frequencia++;


	palabrasDeTrigrama palabras;
	palabras.segundaPalabra = diccionarioCompleto[palabra2].indice;
	palabras.terceraPalabra = diccionarioCompleto[palabra3].indice;

	if (diccionarioCompleto[palabra1].segundaYTerceraPalabra.find(palabras) == diccionarioCompleto[palabra1].segundaYTerceraPalabra.end()){

		//Se agrega el trigrama con freq = 0;
		diccionarioCompleto[palabra1].segundaYTerceraPalabra[palabras] = 0;
	}

	diccionarioCompleto[palabra1].segundaYTerceraPalabra[palabras]++;
}

void agregarPalabraAlDiccionario(string palabra){

	if ( diccionarioCompleto.find(palabra) == diccionarioCompleto.end() ){
		//Entrar aca significa que la palabra no esta en el diccionario
		diccionarioCompleto[palabra].frequencia = 0;
		diccionarioCompleto[palabra].indice = diccionarioCompleto.size();
		diccionarioCompleto[palabra].apariciones = new set<int>; //hacerle delete
		//diccionarioCompleto[palabra].segundaYTerceraPalabra = new map<palabrasDeTrigrama,int,comparadorDeTrigramas>;
	}
}

void agregarPalabraSueltaAlDiccionario(string palabra){
	agregarPalabraAlDiccionario(palabra);
	diccionarioCompleto[palabra].frequencia++;
}





void cargarDiccionarioAnterior(){
	ifstream archivoDiccionario;
	archivoDiccionario.open("diccionario15.txt");

	int indice;
	string palabra;
	int frecuencia;

	while (archivoDiccionario>>indice && archivoDiccionario>>palabra && archivoDiccionario>>frecuencia && !archivoDiccionario.eof()){

		diccionarioCompleto[palabra].indice = indice;
		diccionarioCompleto[palabra].frequencia = frecuencia;
		diccionarioCompleto[palabra].apariciones = new set<int>;

	}

}

void guardarDiccionario(){
	ofstream archivoDiccionario;
	archivoDiccionario.open("diccionario16.txt");

	for( map<string,datosDeUnaPAlabraDelDiccionario>::iterator iterador = diccionarioCompleto.begin() ; iterador != diccionarioCompleto.end(); ++iterador){
		archivoDiccionario<<(*iterador).second.indice<<" ";
		archivoDiccionario<<(*iterador).first<<" ";
		archivoDiccionario<<(*iterador).second.frequencia<<"\n";
	}	//archivoDiccionario<<(*iterador).second.archivo<<"\n";

	archivoDiccionario.close();
}


//Guarda los trigramas y vacia los sets y mapas
void guardarTrigramasAparicionesYVaciarDatos(){

	//por cada palabra
		//guardar todas las apariciones el set de apariciones se debe cargar afuera
		//guardar todos los trigramas
		//probar si es mas rapido hacer todo de una o hacer una pasada para guardar en el de apariciones primero y en el de trigramas despues
		//hacer clear de las listas+

	string fileNameApariciones;
	fileNameApariciones = "apariciones";

	int numeroDeArchivo = 16;
	std::ostringstream nro;
	nro << numeroDeArchivo;
	fileNameApariciones += nro.str();

	fileNameApariciones += ".txt";


	ofstream archivoDeApariciones;
	archivoDeApariciones.open(fileNameApariciones.c_str());//, ios::app);


	string fileNameTrigramas;
	fileNameTrigramas = "trigramas";
	fileNameTrigramas += nro.str();//Definido arriba
	fileNameTrigramas += ".txt";


	ofstream archivoDeTrigramas;
	archivoDeTrigramas.open(fileNameTrigramas.c_str());//, ios::app);

	for (map<string,datosDeUnaPAlabraDelDiccionario>::iterator itDicc = diccionarioCompleto.begin() ; itDicc != diccionarioCompleto.end(); ++itDicc){

		string palabraActual = (*itDicc).first;

		////////ITERACION SOBRE EL SET DE APARICIONES///////////////
		set<int>* setActual  = diccionarioCompleto[palabraActual].apariciones ;
		if ( setActual != nullptr){
			if (setActual->size() > 3){
				archivoDeApariciones<<diccionarioCompleto[palabraActual].indice<<" ";
				for (set<int>::iterator itSet =  setActual->begin(); itSet != setActual->end(); ++itSet){
					archivoDeApariciones<<(*itSet)<<" ";
				}
				archivoDeApariciones<<"$ \n";
				setActual->clear();
			}
		}

		////////ITERACION SOBRE EL SET DE TRIGRAMAS///////////////
		map<palabrasDeTrigrama,int,comparadorDeTrigramas>* mapActual = &diccionarioCompleto[palabraActual].segundaYTerceraPalabra;
		if (mapActual->size() > 0 ){
			for (map<palabrasDeTrigrama,int,comparadorDeTrigramas>::iterator itMap =  mapActual->begin(); itMap != mapActual->end(); ++itMap){
				archivoDeTrigramas<<diccionarioCompleto[palabraActual].indice<<" ";
				archivoDeTrigramas<<(*itMap).first.segundaPalabra<<" ";
				archivoDeTrigramas<<(*itMap).first.terceraPalabra<<" ";
				archivoDeTrigramas<<(*itMap).second<<"\n";
			}
		}
		mapActual->clear();
	}

	archivoDeApariciones.close();
	archivoDeTrigramas.close();

}







void encontrarFrecuenciaPromedioDelDiccionario(){
	ifstream archivoDiccionario;
	archivoDiccionario.open("diccionario16.txt");


	int indice;
	unsigned int cantidadDePalabras = 0;
	string palabra;
	int frecuenciaObtenida;
	unsigned long frecuenciaTotal = 0;

	while(archivoDiccionario>>indice && archivoDiccionario>>palabra && archivoDiccionario>>frecuenciaObtenida && !archivoDiccionario.eof()){
		cantidadDePalabras++;
		frecuenciaTotal += frecuenciaObtenida;
	}

	cout<<"Cantidad de palabras: "<<cantidadDePalabras<<"\n";
	cout<<"Frecuencia total: "<<frecuenciaTotal<<"\n";
	cout<<"Frecuencia promedio: "<<(frecuenciaTotal/cantidadDePalabras)<<"\n";

	archivoDiccionario.close();

}

void reducirYGuardarDiccionario(){

	//abro el archivo del diccionario
	//Leo el indice, palabra, frecuencia
	//Si la frecuencia es mayor o igual  a 100 se carga todo al diccionarioPorIndice
	//Si no no pasa nada

	//Al final lo guardo todo en un diccionario reducido

	ifstream archivoDiccionarioCompleto;
	archivoDiccionarioCompleto.open("diccionario16.txt");

	int indice;
	string palabra;
	int frecuencia;

	while(archivoDiccionarioCompleto>>indice && archivoDiccionarioCompleto>>palabra && archivoDiccionarioCompleto>>frecuencia && !archivoDiccionarioCompleto.eof()){
		if (frecuencia>=100){
			diccionarioPorIndice[indice].palabra = palabra;
			diccionarioPorIndice[indice].frecuencia = frecuencia;
		}
	}

	archivoDiccionarioCompleto.close();


	ofstream archivoDiccionarioReducido;
	archivoDiccionarioReducido.open("diccionarioReducido.txt");

	for(map<int, sPalabraYFrecuencia>::iterator itDic = diccionarioPorIndice.begin(); itDic != diccionarioPorIndice.end(); ++itDic){
		archivoDiccionarioReducido<<itDic->first<<" ";
		archivoDiccionarioReducido<<itDic->second.palabra<<" ";
		archivoDiccionarioReducido<<itDic->second.frecuencia<<"\n";
	}

	archivoDiccionarioReducido.close();

}

/////////////////////////////////////////////////////////////////////////////////////
//////////////ESTO ES PARA REDUCIR APARICIONES CON EL DICCIONARIO YA REDUCIDO////////

void cargarDiccionarioReducido(){
	ifstream archivoDiccionarioReducido;
	//archivoDiccionarioReducido.open("diccionarioDePrueba.txt");
	archivoDiccionarioReducido.open("diccionarioReducido.txt");

	int indice;
	string palabra;
	int frecuencia;

	while (archivoDiccionarioReducido>>indice && archivoDiccionarioReducido>>palabra && archivoDiccionarioReducido>>frecuencia){

		diccionarioPorIndice[indice].palabra = palabra;
		diccionarioPorIndice[indice].frecuencia = frecuencia;
	}

	diccionarioPorIndice[1].palabra = CUALQUIER_PALABRA;
	diccionarioPorIndice[1].frecuencia = 0;

	archivoDiccionarioReducido.close();
}



void filtrarArchivosDeApariciones(){
	cargarDiccionarioReducido();

	ifstream archivoDeApariciones;
	archivoDeApariciones.open("mergear/aparicionesReducido.txt");

	ofstream appReducido;
	appReducido.open("mergear/aparicionesReducidoYFiltrado.txt");

	int indiceDePalabra;
	//Este nro surge de hacer 174000 maxima cant de particiones * 7 bytes como maximo cada uno(6 para el nro y 1 para el espacio usado como separador
	//Y con 100 bytes mas por las dudas
	char listaDeApariciones[1218100];

	while ( archivoDeApariciones>>indiceDePalabra){
		//cout<<"Indice de palabra: "<<indiceDePalabra<<"\n";
		archivoDeApariciones.getline(listaDeApariciones,1218100);

		if (diccionarioPorIndice.find(indiceDePalabra) != diccionarioPorIndice.end()){
			/*cout<<indiceDePalabra<<" ";
			cout<<listaDeApariciones<<"\n";
			*/
			appReducido<<indiceDePalabra<<" ";
			appReducido<<listaDeApariciones<<"\n";
		}
	}
	appReducido.close();
	archivoDeApariciones.close();


}





void filtrarPorAparicionesONoApariciones(){

	unsigned long primeraAparicion = 0;//250000000/23000;//0;
	unsigned long ultimaAparicion = 180317;//500000008/23000;//9;
	unsigned long medio = (ultimaAparicion - primeraAparicion)/2;//5;

	//cout<<primeraAparicion<<" "<<ultimaAparicion<<" "<<medio;

	unsigned long contadorDeAparicion = primeraAparicion;
	set<unsigned long> setDeApariciones;

	//ESTO ES PARA PROBAR
	ifstream archivoDeApariciones;
	//archivoDeApariciones.open("app1Test.txt");
	archivoDeApariciones.open("mergear/aparicionesCompleto.txt");

	ofstream archivoDeAparicionesReducido;
	//archivoDeAparicionesReducido.open("app1ReducidoTest.txt");
	archivoDeAparicionesReducido.open("mergear/aparicionesReducido.txt");


	//Primero saco el indice
	unsigned long indiceDePalabra;

	while (archivoDeApariciones>>indiceDePalabra){
		string aparicionActual;
		archivoDeApariciones>>aparicionActual;



		while(aparicionActual != "$"){
			setDeApariciones.insert( atoi(aparicionActual.c_str()) );
			archivoDeApariciones>>aparicionActual;
		}

		if (setDeApariciones.size() <= medio){
			//Guardo todo igual agregandole como indice - 1/0 - lista - $ - \n
			archivoDeAparicionesReducido<<indiceDePalabra<<" "<<"1 ";
			for (set<unsigned long>::iterator itSet = setDeApariciones.begin();itSet != setDeApariciones.end(); ++itSet){
				archivoDeAparicionesReducido<<(*itSet)<<" ";
			}
			archivoDeAparicionesReducido<<"$ \n";
			setDeApariciones.clear();
		}
		else{
			archivoDeAparicionesReducido<<indiceDePalabra<<" "<<"0 ";
			contadorDeAparicion = primeraAparicion;

			set<unsigned long>::iterator itSet = setDeApariciones.begin();
			while (itSet != setDeApariciones.end()){

				while ((*itSet)>contadorDeAparicion){
					archivoDeAparicionesReducido<<contadorDeAparicion<<" ";
					contadorDeAparicion++;
				}

				contadorDeAparicion++;
				++itSet;
			}

			while (contadorDeAparicion <= ultimaAparicion){
				archivoDeAparicionesReducido<<contadorDeAparicion<<" ";
				contadorDeAparicion++;
			}


			archivoDeAparicionesReducido<<"$ \n";
			setDeApariciones.clear();
		}
	}

	archivoDeAparicionesReducido.close();
	archivoDeApariciones.close();
}






//El "diccionario16Test.txt" tiene TODAS las palabras, CUALQUIER_PALABRA incluida
void cargarDiccionarioPorIndice(){
	ifstream archivoDiccionarioReducido;
	archivoDiccionarioReducido.open("diccionario16Test.txt");

	int indice;
	string palabra;
	int frecuencia;

	while (archivoDiccionarioReducido>>indice && archivoDiccionarioReducido>>palabra && archivoDiccionarioReducido>>frecuencia){

		diccionarioPorIndice[indice].palabra = palabra;
		diccionarioPorIndice[indice].frecuencia = frecuencia;
	}

	archivoDiccionarioReducido.close();
}



void copiarAparicionesEnArchivo(ifstream &archDeApariciones, ofstream &archDeEscritura){
	string aparicion;
	archDeApariciones>>aparicion;
	while(aparicion != "$"){
		archDeEscritura<<aparicion<<" ";
		archDeApariciones>>aparicion;
	}
}




void mergearArchivosDeApariciones(string numero1, string numero2){

	cargarDiccionarioPorIndice();

	ifstream apariciones1, apariciones2;
	//apariciones1.open("mergeTest1.txt");
	//apariciones2.open("mergeTest2.txt");


	string fileName1 = "mergear/apariciones";
	fileName1 += numero1;
	fileName1 += ".txt";
	//apariciones1.open("mergear/apariciones2.txt");
	apariciones1.open(fileName1.c_str());


	string fileName2 = "mergear/apariciones";
	fileName2 += numero2;
	fileName2 += ".txt";
	//apariciones2.open("mergear/apariciones3.txt");
	apariciones2.open(fileName2.c_str());



	int indice1,indice2;


	ofstream aparicionesMerged;
	//aparicionesMerged.open("mergedTest.txt");

	string fileNameMergeado = "mergear/apariciones";
	fileNameMergeado += numero1;
	fileNameMergeado += "_";
	fileNameMergeado += numero2;
	fileNameMergeado += ".txt";
	//aparicionesMerged.open("mergear/apariciones2_3.txt");
	aparicionesMerged.open(fileNameMergeado.c_str());



	apariciones1>>indice1;
	apariciones2>>indice2;
	while(!apariciones1.eof() && !apariciones2.eof()){

		if(diccionarioPorIndice[indice1].palabra == diccionarioPorIndice[indice2].palabra){

			aparicionesMerged<<indice1<<" ";

			copiarAparicionesEnArchivo(apariciones1,aparicionesMerged);
			copiarAparicionesEnArchivo(apariciones2,aparicionesMerged);

			aparicionesMerged<<"$ \n";

			//Avanzo en los dos indices
			apariciones1>>indice1;
			apariciones2>>indice2;
		}
		else if (diccionarioPorIndice[indice1].palabra > diccionarioPorIndice[indice2].palabra){
			aparicionesMerged<<indice2<<" ";

			copiarAparicionesEnArchivo(apariciones2,aparicionesMerged);

			aparicionesMerged<<"$ \n";

			apariciones2>>indice2;
		}
		else{
			aparicionesMerged<<indice1<<" ";

			copiarAparicionesEnArchivo(apariciones1,aparicionesMerged);

			aparicionesMerged<<"$ \n";

			apariciones1>>indice1;
		}
	}


	//Ahora hay que copiar todas las palabras que faltan del archivo que no este en el eof

	if(!apariciones1.eof()){
		aparicionesMerged<<indice1;
		char listaDeApariciones[1218100];
		while (!apariciones1.eof()){
			apariciones1.getline(listaDeApariciones,1218100);
			aparicionesMerged<<listaDeApariciones<<"\n";
		}
	}

	if(!apariciones2.eof()){
		aparicionesMerged<<indice2;
		char listaDeApariciones[1218100];
		while (!apariciones2.eof()){
			apariciones2.getline(listaDeApariciones,1218100);
			aparicionesMerged<<listaDeApariciones<<"\n";
		}
	}

	apariciones1.close();
	apariciones2.close();

	aparicionesMerged.close();
}





//////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////ESTA PARTE VA A SER PARA MERGEAR ARCHIVOS DE TRIGRAMAS/////////////////////

void mergearArchivosDeTrigramas(string numero1, string numero2){

	//Carga TODAS las palabras, CUALQUIER_PALABRA incluida
	cargarDiccionarioPorIndice();

	ifstream trigramasA, trigramasB;

	string fileNameA = "trigramas/trigramas";
	fileNameA += numero1;
	fileNameA += ".txt";
	trigramasA.open(fileNameA.c_str());

//	trigramasA.open("trigramas/trigramas1Test.txt");



	string fileNameB = "trigramas/trigramas";
	fileNameB += numero2;
	fileNameB += ".txt";
	trigramasB.open(fileNameB.c_str());

//	trigramasB.open("trigramas/trigramas2Test.txt");

	//Se leen los indices
	unsigned long palabra1A,palabra1B;
	unsigned long palabra2A,palabra2B;
	unsigned long palabra3A,palabra3B;
	unsigned long frecuenciaA,frecuenciaB;

	trigramasA>>palabra1A;
	trigramasA>>palabra2A;
	trigramasA>>palabra3A;
	trigramasA>>frecuenciaA;

	trigramasB>>palabra1B;
	trigramasB>>palabra2B;
	trigramasB>>palabra3B;
	trigramasB>>frecuenciaB;




	ofstream trigramasMerged;

	string fileNameMergeado = "trigramas/trigramas";
	fileNameMergeado += numero1;
	fileNameMergeado += "_";
	fileNameMergeado += numero2;
	fileNameMergeado += ".txt";
	trigramasMerged.open(fileNameMergeado.c_str());

	//trigramasMerged.open("trigramas/trigramasMergedTest.txt");




	while(!trigramasA.eof() && !trigramasB.eof()){


		if(diccionarioPorIndice[palabra1A].palabra == diccionarioPorIndice[palabra1B].palabra){

			if(diccionarioPorIndice[palabra2A].palabra == diccionarioPorIndice[palabra2B].palabra){

				if(diccionarioPorIndice[palabra3A].palabra == diccionarioPorIndice[palabra3B].palabra){
					trigramasMerged<<palabra1A<<" "<<palabra2A<<" "<<palabra3A<<" "<<(frecuenciaA + frecuenciaB)<<"\n";
					trigramasA>>palabra1A;
					trigramasA>>palabra2A;
					trigramasA>>palabra3A;
					trigramasA>>frecuenciaA;

					trigramasB>>palabra1B;
					trigramasB>>palabra2B;
					trigramasB>>palabra3B;
					trigramasB>>frecuenciaB;
				}
				else if (diccionarioPorIndice[palabra3A].palabra < diccionarioPorIndice[palabra3B].palabra){
					trigramasMerged<<palabra1A<<" "<<palabra2A<<" "<<palabra3A<<" "<<frecuenciaA<<"\n";
					trigramasA>>palabra1A;
					trigramasA>>palabra2A;
					trigramasA>>palabra3A;
					trigramasA>>frecuenciaA;
				}
				else{
					trigramasMerged<<palabra1B<<" "<<palabra2B<<" "<<palabra3B<<" "<<frecuenciaB<<"\n";
					trigramasB>>palabra1B;
					trigramasB>>palabra2B;
					trigramasB>>palabra3B;
					trigramasB>>frecuenciaB;
				}

			}//viene de: if(diccionarioPorIndice[palabra2A].palabra == diccionarioPorIndice[palabra2B].palabra)
			else if (diccionarioPorIndice[palabra2A].palabra < diccionarioPorIndice[palabra2B].palabra){
				trigramasMerged<<palabra1A<<" "<<palabra2A<<" "<<palabra3A<<" "<<frecuenciaA<<"\n";
				trigramasA>>palabra1A;
				trigramasA>>palabra2A;
				trigramasA>>palabra3A;
				trigramasA>>frecuenciaA;
			}
			else{
				trigramasMerged<<palabra1B<<" "<<palabra2B<<" "<<palabra3B<<" "<<frecuenciaB<<"\n";
				trigramasB>>palabra1B;
				trigramasB>>palabra2B;
				trigramasB>>palabra3B;
				trigramasB>>frecuenciaB;
			}
		}//viene de: if(diccionarioPorIndice[palabra1A].palabra == diccionarioPorIndice[palabra1B].palabra)
		else if (diccionarioPorIndice[palabra1A].palabra < diccionarioPorIndice[palabra1B].palabra){
			trigramasMerged<<palabra1A<<" "<<palabra2A<<" "<<palabra3A<<" "<<frecuenciaA<<"\n";
			trigramasA>>palabra1A;
			trigramasA>>palabra2A;
			trigramasA>>palabra3A;
			trigramasA>>frecuenciaA;
		}
		else{
			trigramasMerged<<palabra1B<<" "<<palabra2B<<" "<<palabra3B<<" "<<frecuenciaB<<"\n";
			trigramasB>>palabra1B;
			trigramasB>>palabra2B;
			trigramasB>>palabra3B;
			trigramasB>>frecuenciaB;
		}
	}



	while (!trigramasA.eof()){
		trigramasMerged<<palabra1A<<" "<<palabra2A<<" "<<palabra3A<<" "<<frecuenciaA<<"\n";
		trigramasA>>palabra1A;
		trigramasA>>palabra2A;
		trigramasA>>palabra3A;
		trigramasA>>frecuenciaA;
	}

	while (!trigramasB.eof()){
		trigramasMerged<<palabra1B<<" "<<palabra2B<<" "<<palabra3B<<" "<<frecuenciaB<<"\n";
		trigramasB>>palabra1B;
		trigramasB>>palabra2B;
		trigramasB>>palabra3B;
		trigramasB>>frecuenciaB;
	}

	trigramasA.close();
	trigramasB.close();
	trigramasMerged.close();

}


void reducirArchivoDeTrigramas(){
	ifstream trigramas;
	//trigramas.open("trigramas/trigramasCompleto.txt");
	trigramas.open("trigramas/trigramasFiltrado.txt");

	ofstream trigramasReducido;
	//trigramasReducido.open("trigramas/trigramasReducido.txt");
	trigramasReducido.open("trigramas/trigramasFiltradoReducido.txt");


	long palabra1,palabra2,palabra3,frecuencia;
	long nivelActual1 = -1;
	long nivelActual2 = -1;

	while (trigramas>>palabra1 && trigramas>>palabra2 && trigramas>>palabra3 && trigramas>>frecuencia ){
		if( nivelActual1 != palabra1){
			nivelActual1 = palabra1;
			nivelActual2 = palabra2;
			trigramasReducido<<SEPARADOR_PRIMERAS_PALABRAS<<palabra1<<SEPARADOR_SEGUNDAS_PALABRAS<<palabra2<<SEPARADOR_TERCERAS_PALABRAS<<palabra3<<SEPARADOR_PALABRA_FRECUENCIA<<frecuencia;
		}
		else{//nivelActual1 == palabra1

			if (nivelActual2 != palabra2){
				nivelActual2 = palabra2;
				trigramasReducido<<SEPARADOR_SEGUNDAS_PALABRAS<<palabra2<<SEPARADOR_TERCERAS_PALABRAS<<palabra3<<SEPARADOR_PALABRA_FRECUENCIA<<frecuencia;
			}
			else{
				trigramasReducido<<SEPARADOR_TERCERAS_PALABRAS<<palabra3<<SEPARADOR_PALABRA_FRECUENCIA<<frecuencia;
			}
		}
	}

	trigramasReducido.close();
	trigramas.close();
}






void filtrarArchivoDeTrigramas(){
	ifstream trigramasCompleto;
	trigramasCompleto.open("trigramas/trigramasCompleto.txt");

	ofstream trigramasFiltrado;
	trigramasFiltrado.open("trigramas/trigramasFiltrado.txt");


	cargarDiccionarioReducido();//Ver si carga CUALQUIER PALABRA

	long palabra1,palabra2,palabra3,frecuencia;
	while (trigramasCompleto>>palabra1 && trigramasCompleto>>palabra2 && trigramasCompleto>>palabra3 && trigramasCompleto>>frecuencia ){

		if (diccionarioPorIndice.find(palabra1) != diccionarioPorIndice.end() &&
			diccionarioPorIndice.find(palabra2) != diccionarioPorIndice.end() &&
			diccionarioPorIndice.find(palabra3) != diccionarioPorIndice.end() ){
			//Entrar aca significa que todos los indices del trigrama estan en el diccinario
			trigramasFiltrado<<palabra1<<" "<<palabra2<<" "<<palabra3<<" "<<frecuencia<<"\n";
		}

	}

	trigramasCompleto.close();
	trigramasFiltrado.close();
}































void cargarYGuardarDiccionarioFiltradoPorPalabra(){

	ifstream dic("diccionarioReducido.txt");
	ofstream dicFiltrado("diccionarioFiltradoOrdenadoPorPalabra.txt");

	int indice;
	string palabra;
	int frecuencia;

	diccionarioCompleto[CUALQUIER_PALABRA].indice = 1;
	diccionarioCompleto[CUALQUIER_PALABRA].frequencia = 0;

	while (dic>>indice && dic>>palabra && dic>>frecuencia){
		diccionarioCompleto[palabra].indice = indice;
		diccionarioCompleto[palabra].frequencia = frecuencia;
	}

	for( map<string,datosDeUnaPAlabraDelDiccionario>::iterator iterador = diccionarioCompleto.begin() ; iterador != diccionarioCompleto.end(); ++iterador){
		dicFiltrado<<(*iterador).second.indice<<" ";
		dicFiltrado<<(*iterador).first<<" ";
		dicFiltrado<<(*iterador).second.frequencia<<"\n";
	}




	dic.close();
	dicFiltrado.close();
}


































































void agregarTrigramas(vector<string> &palabras){

	agregarPalabraAlDiccionario(CUALQUIER_PALABRA);

	size_t tam = palabras.size();

	string ultimaPalabra1,ultimaPalabra2;


	if (tam > 2 ){
		for(size_t i = 0; i < tam - 2; i++){
			agregarTrigrama(palabras.at(i), palabras.at(i+1), palabras.at(i+2));
			ultimaPalabra1 = palabras.at(i+1);
			ultimaPalabra2 = palabras.at(i+2);
		}
		//agregarPalabraSueltaAlDiccionario(ultimaPalabra1);
		agregarTrigrama(ultimaPalabra1,ultimaPalabra2, CUALQUIER_PALABRA);
		agregarPalabraSueltaAlDiccionario(ultimaPalabra2);
	}
	else if (tam == 2 ){//Si una frase tuviera dos palabras, no funcionaria el for
		agregarTrigrama(palabras.at(0), palabras.at(1),CUALQUIER_PALABRA);
		agregarPalabraSueltaAlDiccionario(palabras.at(1));
	}
	else{
		agregarPalabraSueltaAlDiccionario(palabras.at(0));
	}

}


